如何快速构建基于Spring4.0的Rest API（攻略）

Spring BootSecurityREST接口

这是关于使用Spring MVC创建Web API的另一个教程。这并不是一个非常精细的教程，而仅仅是一个演习（攻略）。本教程旨在创建一个提供服务器端API的应用，并且使用Mongo作为它的数据库，使用Spring Security作为安全框架。
准备开始——POM
由于我是一个maven脑残粉，所以这个项目还是基于maven的。现在Spring 4.0 RC2已经发布了，所以我决定使用最新的依赖管理工具。本文使用的pom.xml如下：使用这个配置创建Spring MVC应用确实非常简单。这里面比较新鲜的东西就是dependencyManagement 元素。详解猛戳这儿：http://spring.io/blog/2013/12/03/spring-framework-4-0-rc2-available
配置
这个应用可以使用JavaConfig完成配置。我把它切分为下面几个部分：
ServicesConfig（服务配置）
无需扫描组件，配置真的非常简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Configuration
publicclass ServicesConfig {
    @Autowired
    private AccountRepository accountRepository;
 
    @Bean
    public  UserService userService() {
        returnnew UserService(accountRepository);
    }
 
    @Bean
    public PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }
}

PersistenceConfig（持久层配置）我们想要一个配置了所有可用仓库的MONGODB配置。在这个简单的应用中我们只用了一个仓库，所以配置也非常的简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@Configuration
classPersistenceConfig {
    @Bean
    publicAccountRepository accountRepository() throwsUnknownHostException {
        returnnew MongoAccountRepository(mongoTemplate());
    }
 
    @Bean
    publicMongoDbFactory mongoDbFactory() throwsUnknownHostException {
        returnnew SimpleMongoDbFactory(newMongo(), "r");
    }
 
    @Bean
    publicMongoTemplate mongoTemplate() throwsUnknownHostException {
        MongoTemplate template = newMongoTemplate(mongoDbFactory(), mongoConverter());
        returntemplate;
    }
 
    @Bean
    publicMongoTypeMapper mongoTypeMapper() {
        returnnew DefaultMongoTypeMapper(null);
    }
 
    @Bean
    publicMongoMappingContext mongoMappingContext() {
        returnnew MongoMappingContext();
    }
 
    @Bean
    publicMappingMongoConverter mongoConverter() throwsUnknownHostException {
        MappingMongoConverter converter = newMappingMongoConverter(mongoDbFactory(), mongoMappingContext());
        converter.setTypeMapper(mongoTypeMapper());
        returnconverter;
    }
}

SecurityConfig（安全配置）
理论上，Spring Security 3.2完全可以使用JavaConfig。但对于我这也仅仅是一个理论，所以这里还是选择xml配置的方式：
123@Configuration``@ImportResource``(``"classpath:spring-security-context.xml"``)``public``class`` SecurityConfig {}使用这个xml就让API能使用基本的安全机制了。
WebAppInitializer（初始化）
我们不想使用web.xml，所以使用下面的代码配置整个应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@Order(2)
publicclass WebAppInitializer extendsAbstractAnnotationConfigDispatcherServletInitializer {
 
    @Override
    protectedString[] getServletMappings() {
        returnnew String[]{"/"};
    }
 
    @Override
    protectedClass[] getRootConfigClasses() {
        returnnew Class[] {ServicesConfig.class, PersistenceConfig.class, SecurityConfig.class};
    }
 
    @Override
    protectedClass[] getServletConfigClasses() {
        returnnew Class[] {WebMvcConfig.class};
    }
 
    @Override
    protectedFilter[] getServletFilters() {
        CharacterEncodingFilter characterEncodingFilter = newCharacterEncodingFilter();
        characterEncodingFilter.setEncoding("UTF-8");
        characterEncodingFilter.setForceEncoding(true);
        returnnew Filter[] {characterEncodingFilter};
    }
 
    @Override
    protectedvoid customizeRegistration(ServletRegistration.Dynamic registration) {        
        registration.setInitParameter("spring.profiles.active","default");
    }
}

WebAppSecurityInitializer （安全配置初始化）
相对于Spring3，可以使用下面这种更加新颖的特性来完成配置：
12@Order``(``1``)``public``class`` WebAppSecurityInitializer ``extends``AbstractSecurityWebApplicationInitializer {}WebMvcConfig （Mvc配置）
调度控制器配置。这个也非常简单，仅仅包含了构建一个简单API的最重要配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@Configuration
@ComponentScan(basePackages = { "pl.codeleak.r"}, includeFilters = {@Filter(value = Controller.class)})
publicclass WebMvcConfig extendsWebMvcConfigurationSupport {
 
    privatestatic final String MESSAGE_SOURCE = "/WEB-INF/i18n/messages";
 
    @Override
    publicRequestMappingHandlerMapping requestMappingHandlerMapping() {
        RequestMappingHandlerMapping requestMappingHandlerMapping = super.requestMappingHandlerMapping();
        requestMappingHandlerMapping.setUseSuffixPatternMatch(false);
        requestMappingHandlerMapping.setUseTrailingSlashMatch(false);
        returnrequestMappingHandlerMapping;
    }
 
    @Bean(name = "messageSource")
    publicMessageSource messageSource() {
        ReloadableResourceBundleMessageSource messageSource = newReloadableResourceBundleMessageSource();
        messageSource.setBasename(MESSAGE_SOURCE);
        messageSource.setCacheSeconds(5);
        returnmessageSource;
    }
 
    @Override
    publicValidator getValidator() {
        LocalValidatorFactoryBean validator = newLocalValidatorFactoryBean();
        validator.setValidationMessageSource(messageSource());
        returnvalidator;
    }
 
    @Override
    publicvoid configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

这就是需要的配置，非常简单吧！

IndexController （INDEX控制器）

为了验证这个配置是正确的，我创建了一个IndexController。功能非常简单，只是简单地返回“Hello World”，示例代码如下：\

1
2
3
4
5
6
7
8
9
@Controller
@RequestMapping("/")
publicclass IndexController {
    @RequestMapping
    @ResponseBody
    publicString index() {
        return"This is an API endpoint.";
    }
}

如果运行一下这个应用，就能够在浏览器中看到返回的“Hello World”文本。

构建API

UserService

为了完成Spring安全框架配置，还需要完成另一个部分：实现之前创建的UserService。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class UserService implementsUserDetailsService {
    private AccountRepository accountRepository;
 
    public UserService(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }
 
    @Override
    public UserDetails loadUserByUsername(String username) throwsUsernameNotFoundException {
        Account account = accountRepository.findByEmail(username);
        if(account == null) {
            throw new UsernameNotFoundException("user not found");
        }
        return  createUser(account);
    }
 
    public  void signin(Account account) {
        SecurityContextHolder.getContext().setAuthentication(authenticate(account));
    }
 
    private Authentication authenticate(Account account) {
        return new UsernamePasswordAuthenticationToken(createUser(account), null, Collections.singleton(createAuthority(account)));  
    }
 
    private  User createUser(Account account) {
        returnnew User(account.getEmail(), account.getPassword(), Collections.singleton(createAuthority(account)));
    }
 
    private  GrantedAuthority createAuthority(Account account) {
        returnnew SimpleGrantedAuthority(account.getRole());
    }
}

构建一个API节点需要处理三个方法：获取当前登陆用户、获取所有用户（可能不是太安全）、创建一个新账户。那么我们就按照这个步骤来进行吧。
Account
Account 将会是我们的第一个Mongo文档。同样也是非常简单：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
@SuppressWarnings("serial")
@Document
public class Account implementsjava.io.Serializable {
 
    @Id
    private String objectId;
 
    @Email
    @Indexed(unique = true)
    private String email;
 
    @JsonIgnore
    @NotBlank
    private String password;
 
    private String role = "ROLE_USER";
 
    private Account() {
 
    }
 
    public Account(String email, String password, String role) {
        this.email = email;
        this.password = password;
        this.role = role;
    }
 
   // getters and setters
}

Repository

先创建一个接口：

1
2
3
4
5
6
7
publicinterface AccountRepository {
    Account save(Account account);
 
    List findAll();
 
    Account findByEmail(String email);
}

接下来创建它的Mongo实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MongoAccountRepository implements AccountRepository {
 
    private MongoTemplate mongoTemplate;
 
    public MongoAccountRepository(MongoTemplate mongoTemplate) {
        this.mongoTemplate = mongoTemplate;
    }
 
    @Override
    public Account save(Account account) {
        mongoTemplate.save(account);
        return account;
    }
 
    @Override
    public List findAll() {
        return mongoTemplate.findAll(Account.class);
    }
 
    @Override
    public Account findByEmail(String email) {
        return mongoTemplate.findOne(Query.query(Criteria.where("email").is(email)), Account.class);
    }
}

API控制器

功能快要完成了。我们需要将内容提供给用户，所以需要创建自己的节点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@Controller
@RequestMapping("api/account")
class AccountController {
 
    private AccountRepository accountRepository;
 
    @Autowired
    public AccountController(AccountRepository accountRepository) {
        this.accountRepository = accountRepository;
    }
 
    @RequestMapping(value = "current", method = RequestMethod.GET)
    @ResponseStatus(value = HttpStatus.OK)
    @ResponseBody
    @PreAuthorize(value = "isAuthenticated()")
    public Account current(Principal principal) {
        Assert.notNull(principal);
        return accountRepository.findByEmail(principal.getName());
    }
 
    @RequestMapping(method = RequestMethod.GET)
    @ResponseStatus(value = HttpStatus.OK)
    @ResponseBody
    @PreAuthorize(value = "isAuthenticated()")
    publicAccounts list() {
        List accounts = accountRepository.findAll();
        return new Accounts(accounts);
    }
 
    @RequestMapping(method = RequestMethod.POST)
    @ResponseStatus(value = HttpStatus.CREATED)
    @ResponseBody
    @PreAuthorize(value = "permitAll()")
    public Account create(@ValidAccount account) {
        accountRepository.save(account);
        returnaccount;
    }
 
    private class Accounts extends ArrayList {
        public  Accounts(List accounts) {
            super(accounts);
        }
    }
}

我希望你能明白：因为需要直接连接数据库，所以没有对密码进行编码。如果你比较在意这些小细节，那么可以稍后修改。目前这种方式是OK的。
完成
最后我考虑到还需要一个错误处理器，这样用户就可以看到JSON格式的错误信息而不是HTML。使用Spring Mvc以及@ControllerAdvice很容易实现这一点：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@ControllerAdvice
public class ErrorHandler {
 
    @ExceptionHandler(value = Exception.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ResponseBody
    public ErrorResponse errorResponse(Exception exception) {
        returnnew ErrorResponse(exception.getMessage());
    }
 
}
 
public class ErrorResponse {
    private String message;
    public ErrorResponse(String message) {
        this.message = message;
    }
    public String getMessage() {
        returnmessage;
    }
}

如果你想了解关于Spring4 中@ControllerAdvice的用法，请点击以下链接。
测试一下这个app
作为一个单元测试极客，本来应该先创建一个单元测试。但是……这次哥想用用新的工具：Postman（Chrome 插件），所以请往下看我是怎么做的：
获取所有account（非授权）

提交account（无需授权）

获取所有account（已授权）

获取当前account（已授权）

结束语
以上就是所有内容，希望你能像我一样喜欢这种创建项目的方式。创建这个项目以及写这篇文章总共花了我大概三个钟头。其中绝大多数时间是配置安全框架（我希望它在Java中能够更加彻底），以及编写这篇攻略。
原文链接： javacodegeeks 翻译： ImportNew.com - 邬柏
译文链接： http://www.importnew.com/7903.html

Title:如何快速构建基于Spring4.0的Rest API（攻略）

Author:offbye

Created:2015-08-16, 11:38:00

Updated:2016-05-13, 00:38:58

Full URL:http://offbye.com/2015/08/16/如何快速构建基于Spring4.0的Rest API（攻略）/

License: "CC BY-NC-SA 4.0" Keep Link & Author if Distribute.

CSDN原文: http://blog.csdn.net/offbye/article/details/47701121

CSDN PV:436

Contents
,